Info file internals, produced by Makeinfo, -*- Text -*-
from input file internals.texinfo.



This file documents the internals of the GNU compiler.

Copyright (C) 1988 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of
this manual provided the copyright notice and this permission notice
are preserved on all copies.

Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided also that the
section entitled ``GNU CC General Public License'' is included exactly as
in the original, and provided that the entire resulting derived work is
distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual
into another language, under the above conditions for modified versions,
except that the section entitled ``GNU CC General Public License'' and
this permission notice may be included in translations approved by the
Free Software Foundation instead of in the original English.






File: internals,  Node: Misc,  Next: Condition Code,  Prev: Addressing Modes,  Up: Machine Macros

Miscellaneous Parameters
========================

`CASE_VECTOR_MODE'
     An alias for a machine mode name.  This is the machine mode that
     elements of a jump-table should have.

`CASE_VECTOR_PC_RELATIVE'
     Define this macro if jump-tables should contain relative addresses.

`CASE_DROPS_THROUGH'
     Define this if control falls through a `case' insn when the index
     value is out of range.  This means the specified default-label is
     actually ignored by the `case' insn proper.

`IMPLICIT_FIX_EXPR'
     An alias for a tree code that should be used by default for conversion
     of floating point values to fixed point.  Normally, `FIX_ROUND_EXPR'
     is used.

`FIXUNS_TRUNC_LIKE_FIX_TRUNC'
     Define this macro if the same instructions that convert a floating
     point number to a signed fixed point number also convert validly to an
     unsigned one.

`EASY_DIV_EXPR'
     An alias for a tree code that is the easiest kind of division to
     compile code for in the general case.  It may be `TRUNC_DIV_EXPR',
     `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'.  These four
     division operators differ in how they round the result to an integer. 
     `EASY_DIV_EXPR' is used when it is permissible to use any of those
     kinds of division and the choice should be made on the basis of
     efficiency.

`DEFAULT_SIGNED_CHAR'
     An expression whose value is 1 or 0, according to whether the type
     `char' should be signed or unsigned by default.  The user can always
     override this default with the options `-fsigned-char' and
     `-funsigned-char'.

`SCCS_DIRECTIVE'
     Define this if the preprocessor should ignore `#sccs' directives with
     no error message.

`MOVE_MAX'
     The maximum number of bytes that a single instruction can move quickly
     from memory to memory.

`INT_TYPE_SIZE'
     A C expression for the size in bits of the type `int' on the target
     machine.

`SLOW_BYTE_ACCESS'
     Define this macro as a C expression which is nonzero if accessing less
     than a word of memory (i.e. a `char' or a `short') is slow (requires
     more than one instruction).

`SLOW_ZERO_EXTEND'
     Define this macro if zero-extension (of a `char' or `short' to an
     `int') can be done faster if the destination is a register that is
     known to be zero.

     If you define this macro, you must have instruction patterns that
     recognize RTL structures like this:

          (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)


     and likewise for `HImode'.

`SHIFT_COUNT_TRUNCATED'
     Define this macro if shift instructions ignore all but the lowest few
     bits of the shift count.  It implies that a sign-extend or zero-extend
     instruction for the shift count can be omitted.

`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
     A C expression which is nonzero if on this machine it is safe to
     ``convert'' an integer of INPREC bits to one of OUTPREC bits (where
     OUTPREC is smaller than INPREC) by merely operating on it as if it had
     only OUTPREC bits.

     On many machines, this expression can be 1.

`NO_FUNCTION_CSE'
     Define this macro if it is as good or better to call a constant
     function address than to call an address kept in a register.

`STORE_FLAG_VALUE'
     A C expression for the value stored by a store-flag instruction
     (`sCOND') when the condition is true.  This is usually 1 or -1; it is
     required to be an odd number.

     Do not define `STORE_FLAG_VALUE' if the machine has no store-flag
     instructions.

`Pmode'
     An alias for the machine mode for pointers.  Normally the definition
     can be

          #define Pmode SImode


`FUNCTION_MODE'
     An alias for the machine mode used for memory references to functions
     being called, in `call' RTL expressions.  On most machines this should
     be `QImode'.

`CONST_COST (X, CODE)'
     A part of a C `switch' statement that describes the relative costs of
     constant RTL expressions.  It must contain `case' labels for
     expression codes `const_int', `const', `symbol_ref', `label_ref' and
     `const_double'.  Each case must ultimately reach a `return' statement
     to return the relative cost of the use of that kind of constant value
     in an expression.  The cost may depend on the precise value of the
     constant, which is available for examination in X.

     CODE is the expression code---redundant, since it can be obtained with
     `GET_CODE (X)'.

`DOLLARS_IN_IDENTIFIERS'
     Define this if the character `$' should be allowed in identifier names.


File: internals,  Node: Condition Code,  Next: Assembler Format,  Prev: Misc,  Up: Machine Macros

Condition Code Information
==========================

The file `conditions.h' defines a variable `cc_status' to describe how the
condition code was computed (in case the interpretation of the condition
code depends on the instruction that it was set by).  This variable
contains the RTL expressions on which the condition code is currently
based, and several standard flags.

Sometimes additional machine-specific flags must be defined in the machine
description header file.  It can also add additional machine-specific
information by defining `CC_STATUS_MDEP'.

`CC_STATUS_MDEP'
     C code for a data type which is used for declaring the `mdep'
     component of `cc_status'.  It defaults to `int'.

`CC_STATUS_MDEP_INIT'
     A C expression for the initial value of the `mdep' field.  It defaults
     to 0.

`NOTICE_UPDATE_CC (EXP)'
     A C compound statement to set the components of `cc_status'
     appropriately for an insn whose body is EXP.  It is this macro's
     responsibility to recognize insns that set the condition code as a
     byproduct of other activity as well as those that explicitly set
     `(cc0)'.

     If there are insn that do not set the condition code but do alter
     other machine registers, this macro must check to see whether they
     invalidate the expressions that the condition code is recorded as
     reflecting.  For example, on the 68000, insns that store in address
     registers do not set the condition code, which means that usually
     `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns. 
     But suppose that the previous insn set the condition code based on
     location `a4@(102)' and the current insn stores a new value in `a4'. 
     Although the condition code is not changed by this, it will no longer
     be true that it reflects the contents of `a4@(102)'.  Therefore,
     `NOTICE_UPDATE_CC' must alter `cc_status' in this case to say that
     nothing is known about the condition code value.


File: internals,  Node: Assembler Format,  Prev: Condition Code,  Up: Machine Macros

Output of Assembler Code
========================

`ASM_SPEC'
     A C string constant that tells the GNU CC driver program options to
     pass to the assembler.  It can also specify how to translate options
     you give to GNU CC into options for GNU CC to pass to the assembler. 
     See the file `tm-sun3.h' for an example of this.

     Do not define this macro if it does not need to do anything.

`LINK_SPEC'
     A C string constant that tells the GNU CC driver program options to
     pass to the linker.  It can also specify how to translate options you
     give to GNU CC into options for GNU CC to pass to the linker.

     Do not define this macro if it does not need to do anything.

`ASM_FILE_START'
     A C string constant for text to be output at the start of each
     assembler output file.  Normally this is `"#NO_APP"', which is a
     comment that has no effect on most assemblers but tells the GNU
     assembler that it can save time by not checking for certain assembler
     constructs.

`ASM_APP_ON'
     A C string constant for text to be output before each `asm' statement
     or group of consecutive ones.  Normally this is `"#APP"', which is a
     comment that has no effect on most assemblers but tells the GNU
     assembler that it must check the lines that follow for all valid
     assembler constructs.

`ASM_APP_OFF'
     A C string constant for text to be output after each `asm' statement
     or group of consecutive ones.  Normally this is `"#NO_APP"', which
     tells the GNU assembler to resume making the time-saving assumptions
     that are valid for ordinary compiler output.

`TEXT_SECTION_ASM_OP'
     A C string constant for the assembler operation that should precede
     instructions and read-only data.  Normally `".text"' is right.

`DATA_SECTION_ASM_OP'
     A C string constant for the assembler operation to identify the
     following data as writable initialized data.  Normally `".data"' is
     right.

`REGISTER_NAMES'
     A C initializer containing the assembler's names for the machine
     registers, each one as a C string constant.  This is what translates
     register numbers in the compiler into assembler language.

`DBX_REGISTER_NUMBER (REGNO)'
     A C expression that returns the DBX register number for the compiler
     register number REGNO.  In simple cases, the value of this expression
     may be REGNO itself.  But sometimes there are some registers that the
     compiler knows about and DBX does not, or vice versa.  In such cases,
     some register may need to have one number in the compiler and another
     for DBX.

`DBX_NO_XREFS'
     Define this macro if DBX on your system does not support the construct
     `xsTAGNAME'.  On some systems, this construct is used to describe a
     forward reference to a structure named TAGNAME.  On other systems,
     this construct is not supported at all.

`DBX_CONTIN_LENGTH'
     A symbol name in DBX-format debugging information is normally
     continued (split into two separate `.stabs' directives) when it
     exceeds a certain length (by default, 80 characters).  On some
     operating systems, DBX requires this splitting; on others, splitting
     must not be done.  You can inhibit splitting by defining this macro
     with the value zero.  You can override the default splitting-length by
     defining this macro as an expression for the length you desire.

`DBX_CONTIN_CHAR'
     Normally continuation is indicated by adding a `\' character to the
     end of a `.stabs' string when a continuation follows.  To use a
     different character instead, define this macro as a character constant
     for the character you want to use.  Do not define this macro if
     backslash is correct for your system.

`ASM_OUTPUT_LABEL (FILE, NAME)'
     A C statement (sans semicolon) to output to the stdio stream FILE the
     assembler definition of a label named NAME.  Use the expression
     `assemble_name (FILE, NAME)' to output the name itself; before and
     after that, output the additional assembler syntax for defining the
     name, and a newline.

`ASM_DECLARE_FUNCTION_NAME (FILE, NAME)'
     A C statement (sans semicolon) to output to the stdio stream FILE any
     text necessary for declaring the name of a function which is being
     defined.  This macro is responsible for outputting the label
     definition (perhaps using `ASM_OUTPUT_LABEL').

     If this macro is not defined, then the function name is defined in the
     usual manner as a label (by means of `ASM_OUTPUT_LABEL').

`ASM_GLOBALIZE_LABEL (FILE, NAME)'
     A C statement (sans semicolon) to output to the stdio stream FILE some
     commands that will make the label NAME global; that is, available for
     reference from other files.  Use the expression `assemble_name (FILE,
     NAME)' to output the name itself; before and after that, output the
     additional assembler syntax for making that name global, and a newline.

`ASM_OUTPUT_EXTERNAL (FILE, NAME)'
     A C statement (sans semicolon) to output to the stdio stream FILE any
     text necessary for declaring the name of an external symbol which is
     referenced in this compilation but not defined.

     This macro need not be defined if it does not need to output anything.
      The GNU assembler and most Unix assemblers don't require anything.

`ASM_OUTPUT_LABELREF (FILE, NAME)'
     A C statement to output to the stdio stream FILE a reference in
     assembler syntax to a label named NAME.  The character `_' should be
     added to the front of the name, if that is customary on your operating
     system, as it is in most Berkeley Unix systems.  This macro is used in
     `assemble_name'.

`ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM)'
     A C statement to output to the stdio stream FILE a label whose name is
     made from the string PREFIX and the number NUM.  These labels are used
     for internal purposes, and there is no reason for them to appear in
     the symbol table of the object file.  On many systems, the letter `L'
     at the beginning of a label has this effect.  The usual definition of
     this macro is as follows:

          fprintf (FILE, "L%s%d:\n", PREFIX, NUM)


`ASM_OUTPUT_CASE_LABEL (FILE, PREFIX, NUM, TABLE)'
     Define this if the label before a jump-table needs to be output
     specially.  The first three arguments are the same as for
     `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
     which follows (a `jump_insn' containing an `addr_vec' or
     `addr_diff_vec').

     This feature is used on system V to output a `swbeg' statement for the
     table.

     If this macro is not defined, these labels are output with
     `ASM_OUTPUT_INTERNAL_LABEL'.

`ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
     A C expression to assign to OUTVAR (which is a variable of type `char
     *') a newly allocated string made from the string NAME and the number
     NUMBER, with some suitable punctuation added.  Use `alloca' to get
     space for the string.

     This string will be used as the argument to `ASM_OUTPUT_LABELREF' to
     produce an assembler label for an internal static variable whose name
     is NAME.  Therefore, the string must be such as to result in valid
     assembler code.  The argument NUMBER is different each time this macro
     is executed; it prevents conflicts between similarly-named internal
     static variables in different scopes.

     Ideally this string should not be a valid C identifier, to prevent any
     conflict with the user's own symbols.  Most assemblers allow periods
     or percent signs in assembler symbols; putting at least one of these
     between the name and the number will suffice.

`ASM_OUTPUT_ADDR_DIFF_ELT (FILE, VALUE, REL)'
     This macro should be provided on machines where the addresses in a
     dispatch table are relative to the table's own address.

     The definition should be a C statement to output to the stdio stream
     FILE an assembler pseudo-instruction to generate a difference between
     two labels.  VALUE and REL are the numbers of two internal labels. 
     The definitions of these labels are output using
     `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same way
     here.  For example,

          fprintf (FILE, "\t.word L%d-L%d\n",
                   VALUE, REL)


`ASM_OUTPUT_ADDR_VEC_ELT (FILE, VALUE)'
     This macro should be provided on machines where the addresses in a
     dispatch table are absolute.

     The definition should be a C statement to output to the stdio stream
     FILE an assembler pseudo-instruction to generate a reference to a
     label.  VALUE is the number of an internal label whose definition is
     output using `ASM_OUTPUT_INTERNAL_LABEL'.  For example,

          fprintf (FILE, "\t.word L%d\n", VALUE)


`ASM_OUTPUT_DOUBLE (FILE, VALUE)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to assemble a `double' constant whose value is VALUE. 
     VALUE will be a C expression of type `double'.

`ASM_OUTPUT_FLOAT (FILE, VALUE)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to assemble a `float' constant whose value is VALUE. 
     VALUE will be a C expression of type `float'.

`ASM_OUTPUT_INT (FILE, EXP)'
`ASM_OUTPUT_SHORT (FILE, EXP)'
`ASM_OUTPUT_CHAR (FILE, EXP)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to assemble a `int', `short' or `char' constant whose
     value is VALUE.  The argument EXP will be an RTL expression which
     represents a constant value.  Use `output_addr_const (EXP)' to output
     this value as an assembler expression.

`ASM_OUTPUT_BYTE (FILE, VALUE)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to assemble a single byte containing the number VALUE.

`ASM_OUTPUT_ASCII (FILE, PTR, LEN)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to assemble a string constant containing the LEN bytes at
     PTR.  PTR will be a C expression of type `char *' and LEN a C
     expression of type `int'.

     If the assembler has a `.ascii' pseudo-op as found in the Berkeley
     Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'.

`ASM_OUTPUT_SKIP (FILE, NBYTES)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to advance the location counter by NBYTES bytes.  NBYTES
     will be a C expression of type `int'.

`ASM_OUTPUT_ALIGN (FILE, POWER)'
     A C statement to output to the stdio stream FILE an assembler
     instruction to advance the location counter to a multiple of 2 to the
     POWER bytes.  POWER will be a C expression of type `int'.

`ASM_OUTPUT_COMMON (FILE, NAME, SIZE)'
     A C statement (sans semicolon) to output to the stdio stream FILE the
     assembler definition of a common-label named NAME whose size is SIZE
     bytes.  Use the expression `assemble_name (FILE, NAME)' to output the
     name itself; before and after that, output the additional assembler
     syntax for defining the name, and a newline.

     This macro controls how the assembler definitions of uninitialized
     global variables are output.

`ASM_OUTPUT_LOCAL (FILE, NAME, SIZE)'
     A C statement (sans semicolon) to output to the stdio stream FILE the
     assembler definition of a local-common-label named NAME whose size is
     SIZE bytes.  Use the expression `assemble_name (FILE, NAME)' to output
     the name itself; before and after that, output the additional
     assembler syntax for defining the name, and a newline.

     This macro controls how the assembler definitions of uninitialized
     static variables are output.

`TARGET_BELL'
     A C constant expression for the integer value for escape sequence `\a'.

`TARGET_BS'
`TARGET_TAB'
`TARGET_NEWLINE'
     C constant expressions for the integer values for escape sequences
     `\b', `\t' and `\n'.

`TARGET_VT'
`TARGET_FF'
`TARGET_CR'
     C constant expressions for the integer values for escape sequences
     `\v', `\f' and `\r'.

`ASM_OUTPUT_OPCODE (FILE, PTR)'
     Define this macro if you are using an unusual assembler that requires
     different names for the machine instructions.

     The definition is a C statement or statements which output an
     assembler instruction opcode to the stdio stream FILE.  The
     macro-operand PTR is a variable of type `char *' which points to the
     opcode name in its ``internal'' form---the form that is written in the
     machine description.  The definition should output the opcode name to
     FILE, performing any translation you desire, and increment the
     variABLE PTR to point at the end of the opcode so that it will not be
     output twice.

     In fact, your macro definition may process less than the entire opcode
     name, or more than the opcode name; but if you want to process text
     that includes `%'-sequences to substitute operands, you must take care
     of the substitution yourself.  Just be sure to increment PTR over
     whatever text should not be output normally.

     If the macro definition does nothing, the instruction is output in the
     usual way.

`PRINT_OPERAND (FILE, X, CODE)'
     A C compound statement to output to stdio stream FILE the assembler
     syntax for an instruction operand X.  X is an RTL expression.

     CODE is a value that can be used to specify one of several ways of
     printing the operand.  It is used when identical operands must be
     printed differently depending on the context.  CODE comes from the `%'
     specification that was used to request printing of the operand.  If
     the specification was just `%DIGIT' then CODE is 0; if the
     specification was `%LTR DIGIT' then CODE is the ASCII code for LTR.

     If X is a register, this macro should print the register's name.  The
     names can be found in an array `reg_names' whose type is `char *[]'. 
     `reg_names' is initialized from `REGISTER_NAMES'.

     When the machine description has a specification `%PUNCT' (a `%'
     followed by a punctuation character), this macro is called with a null
     pointer for X and the punctuation character for CODE.

`PRINT_OPERAND_ADDRESS (FILE, X)'
     A C compound statement to output to stdio stream FILE the assembler
     syntax for an instruction operand that is a memory reference whose
     address is X.  X is an RTL expression.

`ASM_OPEN_PAREN'
`ASM_CLOSE_PAREN'
     These macros are defined as C string constant, describing the syntax
     in the assembler for grouping arithmetic expressions.  The following
     definitions are correct for most assemblers:

          #define ASM_OPEN_PAREN "("
          #define ASM_CLOSE_PAREN ")"



File: internals,  Node: Config,  Prev: Machine Macros,  Up: Top

The Configuration File
**********************

The configuration file `config-MACHINE.h' contains macro definitions that
describe the machine and system on which the compiler is running.  Most of
the values in it are actually the same on all machines that GNU CC runs on,
so most all configuration files are identical.  But there are some macros
that vary:

`FAILURE_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits after serious errors.

`SUCCESS_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits without serious errors.


